package demo1;
class Person implements Cloneable{
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    String name;
    int age;
}

//异常！
public class Test {
    private String userName = "admin";
    private String password = "123456";

    public  void loginInfo(String userName, String password)
                                 throws UserNameException,PasswordException{
       if (! this.userName.equals(userName)) {
             throw new UserNameException("用户名错误！");
    }
        if (! this.password.equals(password)) {
             throw new PasswordException("用户名错误！");
    }
           System.out.println("登陆成功");
  }

    public static void main(String[] args) {
          try {
           new Test(). loginInfo("admin", "123456");
               } catch (UserNameException e) {
                e.printStackTrace();
               } catch (PasswordException e) {
               e.printStackTrace();
  }
  }












    public static void func() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);

    }

















    public static void main12(String[] args) {
            func();
            System.out.println("after try catch");
        }

    public static void main11(String[] args) {

    }
    public static void main10(String[] args) {
        //对于catch语句多个异常的处理方式相同时：

        int[] array = null;
        try {
            System.out.println(10 / 0);
            System.out.println(array.length); //打印数组的长度


        } catch (Exception e) {//空指针异常
            System.out.println(e.getMessage()); //只打印异常信息——/by zero
            System.out.println(e);               // 打印异常类型：异常信息
            e.printStackTrace();                       //打印信息最全面 ——打印异常类型，打印异常信息，还打印异常所在的代码！



        } finally {
            System.out.println("finally中执行的代码");
        }
        System.out.println("后续代码块");
    }


    public static void main9(String[] args) {
        //情况二 ：catch中捕获的类为Exception类
     /*   int [] array = null;
        try{
            System.out.println(10/0);
            System.out.println(array.length); //打印数组的长度


        }catch (Exception e){//空指针异常
            System.out.println("空指针异常");

        }catch (NullPointerException  e){
            System.out.println("算术异常");
        }finally {
            System.out.println("finally中执行的代码");
        }
        System.out.println("后续代码块");
    }
*/
    }
    public static void main8(String[] args) {
        //try—catch语句
    //    int [] array = {1,2,3,4,5};
        //一个try-catch语句只能捕获一个异常！
        int [] array = null;
        try{
            System.out.println(10/0);
            System.out.println(array.length); //打印数组的长度


        }catch (NullPointerException e){//空指针异常
            System.out.println("空指针异常");

        }catch (ArithmeticException e){

            System.out.println(e.getMessage());   // 只打印异常信息
            System.out.println(e);               // 打印异常类型：异常信息
            e.printStackTrace();
        }finally {
            System.out.println("finally中执行的代码");
        }
        System.out.println("后续代码块");
    }
    public static void main7(String[] args) {
       /*try{
            //此处放置要执行的代码，可以会出现异常

        }catch (要捕获的异常类型 e){
            // 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类
          //   时，就会被捕获到 ，对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码

        }[catch(要捕获的异常类型 e){
            //此处放置处理异常的代码
        }
         finally{
            //此处放置的代码，必定会被执行

        }
        ]
        //后续代码:

            //此处的代码，如果没出现异常或者出现了异常并处理了，则此处代码会被执行
            //若出现了异常但没有被处理，则此处的代码不会被执行！
     注： (1) [] 中的内容可加可不加
              (2) try中的代码块不一定会报异常！



*/


    }
    public static void main6(String[] args) {
        //throw关键字
        int a = 10;
        if(a<20){
            throw new ArithmeticException("胡乱调用了异常类");
        }
        System.out.println(a);

    }

    public static void main5(String[] args) {
        //什么是Error?
        //Error是指java虚拟机无法解决的严重问题，比如：JVM内部错误，资源耗尽 如：栈溢出


    }







    public static void main4(String[] args) {
        //5个关键字
  //throw , throws, finally, try ,catch

    }





    public static void main3(String[] args) {
        //throw关键字与throws关键字的区别
        // throw关键字——用来抛出异常警告。不涉及处理异常的问题！
        int a= 10;
        if(a<20){
            throw new ArrayIndexOutOfBoundsException("数值越界异常");
        }
    }

    public static void main2(String[] args) throws CloneNotSupportedException{
        //编译时异常/受查异常
        //此时出现提示，对于编译时异常—即在编译阶段即提=提醒可能出现的异常进行处理
        Person person1 = new Person("张三", 10);
        Person person2 = (Person) person1.clone();

        /*try {
            Person person2 = (Person) person1.clone();

        }catch (CloneNotSupportedException e){
            System.out.println("出现了克隆异常！！！");
        }*/
        //而对于运行时异常/非受查异常，则不会在编译阶段提醒我们处理可能出现的异常
        //我们也可以进行处理！
try {
        int array[] = {1,2,3,4,5};
       System.out.println(array[10]);
}
catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("出现了数组越界异常");
}

    }





    public static void main1(String[] args) {
 //什么是异常？
        //异常是指代码中除了语法错误之外，出现的问题导致代码出现不正常行为的状况称之为异常！
        //在java中用异常类来表示异常，因为java的思想是一切皆对象。
        // ，比如数组越界，除0，栈溢出
//数组越界：
        int array[] = {1,2,3,4,5};
            System.out.println(array[10]);
//除0
 //System.out.println(10/0);


    }
}
